Personal Computer World 2009 February/PCWFEB09.iso/Software/Resources/Chat & Communication/Digsby build 37/digsby_setup.exe/lib/pyxmpp/jabber/client.pyo

Python Compiled Bytecode | 2008-10-13 | 7KB | 150 lines

# Source Generated with Decompyle++
# File: in.pyo (Python 2.5)

__revision__ = '$Id: client.py 656 2006-08-31 20:13:46Z jajcus $'
__docformat__ = 'restructuredtext en'
import logging
from pyxmpp.jabber.clientstream import LegacyClientStream
from pyxmpp.jabber.disco import DISCO_ITEMS_NS, DISCO_INFO_NS
from pyxmpp.jabber.disco import DiscoInfo, DiscoItems, DiscoIdentity
from pyxmpp.jabber import disco
from pyxmpp.client import Client
from pyxmpp.stanza import Stanza
from pyxmpp.cache import CacheSuite
from pyxmpp.utils import from_utf8
from pyxmpp.interfaces import IFeaturesProvider

class JabberClient(Client):

    def __init__(self, jid = None, password = None, server = None, port = 5222, auth_methods = ('sasl:DIGEST-MD5', 'digest'), tls_settings = None, keepalive = 0, disco_name = u'pyxmpp based Jabber client', disco_category = u'client', disco_type = u'pc'):
        Client.__init__(self, jid, password, server, port, auth_methods, tls_settings, keepalive)
        self.stream_class = LegacyClientStream
        self.disco_items = DiscoItems()
        self.disco_info = DiscoInfo()
        self.disco_identity = DiscoIdentity(self.disco_info, disco_name, disco_category, disco_type)
        self.register_feature(u'dnssrv')
        self.register_feature(u'stringprep')
        self.register_feature(u'urn:ietf:params:xml:ns:xmpp-sasl#c2s')
        self.cache = CacheSuite(max_items = 1000)
        self._JabberClient__logger = logging.getLogger('pyxmpp.jabber.JabberClient')


    def connect(self, register = False):
        Client.connect(self, register)
        if register:
            self.stream.registration_callback = self.process_registration_form



    def register_feature(self, feature_name):
        self.disco_info.add_feature(feature_name)


    def unregister_feature(self, feature_name):
        self.disco_info.remove_feature(feature_name)


    def submit_registration_form(self, form):
        self.stream.submit_registration_form(form)


    def __disco_info(self, iq):
        q = iq.get_query()
        if q.hasProp('node'):
            node = from_utf8(q.prop('node'))
        else:
            node = None
        info = self.disco_get_info(node, iq)
        if isinstance(info, DiscoInfo):
            resp = iq.make_result_response()
            self._JabberClient__logger.debug('Disco-info query: %s preparing response: %s with reply: %s' % (iq.serialize(), resp.serialize(), info.xmlnode.serialize()))
            resp.set_content(info.xmlnode.copyNode(1))
        elif isinstance(info, Stanza):
            resp = info
        else:
            resp = iq.make_error_response('item-not-found')
        self._JabberClient__logger.debug('Disco-info response: %s' % (resp.serialize(),))
        self.stream.send(resp)


    def __disco_items(self, iq):
        q = iq.get_query()
        if q.hasProp('node'):
            node = from_utf8(q.prop('node'))
        else:
            node = None
        items = self.disco_get_items(node, iq)
        if isinstance(items, DiscoItems):
            resp = iq.make_result_response()
            self._JabberClient__logger.debug('Disco-items query: %s preparing response: %s with reply: %s' % (iq.serialize(), resp.serialize(), items.xmlnode.serialize()))
            resp.set_content(items.xmlnode.copyNode(1))
        elif isinstance(items, Stanza):
            resp = items
        else:
            resp = iq.make_error_response('item-not-found')
        self._JabberClient__logger.debug('Disco-items response: %s' % (resp.serialize(),))
        self.stream.send(resp)


    def _session_started(self):
        Client._session_started(self)
        for ob in self.interface_providers:
            if IFeaturesProvider.providedBy(ob):
                for ns in ob.get_features():
                    self.register_feature(ns)




    def authorized(self):
        Client.authorized(self)
        self.stream.set_iq_get_handler('query', DISCO_ITEMS_NS, self._JabberClient__disco_items)
        self.stream.set_iq_get_handler('query', DISCO_INFO_NS, self._JabberClient__disco_info)
        disco.register_disco_cache_fetchers(self.cache, self.stream)


    def disco_get_info(self, node, iq):
        to = iq.get_to()
        if to and to != self.jid:
            return iq.make_error_response('recipient-unavailable')

        if not node and self.disco_info:
            return self.disco_info



    def disco_get_items(self, node, iq):
        to = iq.get_to()
        if to and to != self.jid:
            return iq.make_error_response('recipient-unavailable')

        if not node and self.disco_items:
            return self.disco_items



    def process_registration_form(self, stanza, form):
        _unused = stanza
        self._JabberClient__logger.debug(u'default registration callback started. auto-filling-in the form...')
        if 'FORM_TYPE' not in form or 'jabber:iq:register' not in form['FORM_TYPE'].values:
            raise RuntimeError, 'Unknown form type: %r %r' % (form, form['FORM_TYPE'])

        for field in form:
            if field.name == u'username':
                self._JabberClient__logger.debug(u'Setting username to %r' % (self.jid.node,))
                field.value = self.jid.node
                continue
            if field.name == u'password':
                self._JabberClient__logger.debug_s(u"Setting password to %r.decode('rot13')" % (self.password.encode('rot13'),))
                field.value = self.password
                continue
            if field.required:
                self._JabberClient__logger.debug(u'Unknown required field: %r' % (field.name,))
                raise RuntimeError, 'Unsupported required registration form field %r' % (field.name,)
                continue
            self._JabberClient__logger.debug(u'Unknown field: %r' % (field.name,))

        self.submit_registration_form(form)